<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "https://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/xhtml;charset=UTF-8"/>
<meta http-equiv="X-UA-Compatible" content="IE=11"/>
<meta name="generator" content="Doxygen 1.9.4"/>
<meta name="viewport" content="width=device-width, initial-scale=1"/>
<title>Flow: log/log.hpp File Reference</title>
<link href="tabs.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="jquery.js"></script>
<script type="text/javascript" src="dynsections.js"></script>
<link href="search/search.css" rel="stylesheet" type="text/css"/>
<script type="text/javascript" src="search/searchdata.js"></script>
<script type="text/javascript" src="search/search.js"></script>
<link href="doxygen.css" rel="stylesheet" type="text/css" />
</head>
<body>
<div id="top"><!-- do not remove this div, it is closed by doxygen! -->
<div id="titlearea">
<table cellspacing="0" cellpadding="0">
 <tbody>
 <tr id="projectrow">
  <td id="projectalign">
   <div id="projectname">Flow<span id="projectnumber">&#160;2.0.0</span>
   </div>
   <div id="projectbrief">Flow project: Public API.</div>
  </td>
 </tr>
 </tbody>
</table>
</div>
<!-- end header part -->
<!-- Generated by Doxygen 1.9.4 -->
<script type="text/javascript">
/* @license magnet:?xt=urn:btih:d3d9a9a6595521f9666a5e94cc830dab83b65699&amp;dn=expat.txt MIT */
var searchBox = new SearchBox("searchBox", "search",'Search','.html');
/* @license-end */
</script>
<script type="text/javascript" src="menudata.js"></script>
<script type="text/javascript" src="menu.js"></script>
<script type="text/javascript">
/* @license magnet:?xt=urn:btih:d3d9a9a6595521f9666a5e94cc830dab83b65699&amp;dn=expat.txt MIT */
$(function() {
  initMenu('',true,false,'search.php','Search');
  $(document).ready(function() { init_search(); });
});
/* @license-end */
</script>
<div id="main-nav"></div>
<!-- window showing the filter options -->
<div id="MSearchSelectWindow"
     onmouseover="return searchBox.OnSearchSelectShow()"
     onmouseout="return searchBox.OnSearchSelectHide()"
     onkeydown="return searchBox.OnSearchSelectKey(event)">
</div>

<!-- iframe showing the search results (closed by default) -->
<div id="MSearchResultsWindow">
<iframe src="javascript:void(0)" frameborder="0" 
        name="MSearchResults" id="MSearchResults">
</iframe>
</div>

<div id="nav-path" class="navpath">
  <ul>
<li class="navelem"><a class="el" href="dir_9381a7bbd03577d6d8720c7f35c94ffa.html">log</a></li>  </ul>
</div>
</div><!-- top -->
<div class="header">
  <div class="summary">
<a href="#nested-classes">Classes</a> &#124;
<a href="#namespaces">Namespaces</a> &#124;
<a href="#define-members">Macros</a>  </div>
  <div class="headertitle"><div class="title">log.hpp File Reference</div></div>
</div><!--header-->
<div class="contents">
<table class="memberdecls">
<tr class="heading"><td colspan="2"><h2 class="groupheader"><a id="nested-classes" name="nested-classes"></a>
Classes</h2></td></tr>
<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classflow_1_1log_1_1Component.html">flow::log::Component</a></td></tr>
<tr class="memdesc:"><td class="mdescLeft">&#160;</td><td class="mdescRight">A light-weight class, each object storing a <em>component</em> payload encoding an <code>enum</code> value from <code>enum</code> type of user's choice, and a light-weight ID of that <code>enum</code> type itself.  <a href="classflow_1_1log_1_1Component.html#details">More...</a><br /></td></tr>
<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">struct &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="structflow_1_1log_1_1Msg__metadata.html">flow::log::Msg_metadata</a></td></tr>
<tr class="memdesc:"><td class="mdescLeft">&#160;</td><td class="mdescRight">Simple data store containing all of the information generated at every logging call site by <a class="el" href="namespaceflow_1_1log.html" title="Flow module providing logging functionality.">flow::log</a>, except the message itself, which is passed to <a class="el" href="classflow_1_1log_1_1Logger.html#a934667f16dd6ca0841e521296ab3a6e2" title="Given a message and its severity, logs that message and possibly severity WITHOUT checking whether it...">Logger::do_log()</a> assuming <a class="el" href="classflow_1_1log_1_1Logger.html#ac8a2e7a33fe3fbc0c29ead62ed98c022" title="Given attributes of a hypothetical message that would be logged, return true if that message should b...">Logger::should_log()</a> had returned <code>true</code>.  <a href="structflow_1_1log_1_1Msg__metadata.html#details">More...</a><br /></td></tr>
<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classflow_1_1log_1_1Logger.html">flow::log::Logger</a></td></tr>
<tr class="memdesc:"><td class="mdescLeft">&#160;</td><td class="mdescRight">Interface that the user should implement, passing the implementing <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">Logger</a> into logging classes (Flow's own classes like <a class="el" href="classflow_1_1net__flow_1_1Node.html" title="An object of this class is a single Flow-protocol networking node, in the sense that: (1) it has a di...">net_flow::Node</a>; and user's own logging classes) at construction (plus free/<code>static</code> logging functions).  <a href="classflow_1_1log_1_1Logger.html#details">More...</a><br /></td></tr>
<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:"><td class="memItemLeft" align="right" valign="top">class &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="classflow_1_1log_1_1Log__context.html">flow::log::Log_context</a></td></tr>
<tr class="memdesc:"><td class="mdescLeft">&#160;</td><td class="mdescRight">Convenience class that simply stores a <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">Logger</a> and/or <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">Component</a> passed into a constructor; and returns this <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">Logger</a> and <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">Component</a> via <a class="el" href="classflow_1_1log_1_1Log__context.html#af4db395042b065b00398cd59845dcb4d" title="Returns the stored Logger pointer, particularly as many FLOW_LOG_*() macros expect.">get_logger()</a> and <a class="el" href="classflow_1_1log_1_1Log__context.html#a8a5fef42dc2cedf3c0d1a6e83beb2948" title="Returns reference to the stored Component object, particularly as many FLOW_LOG_*() macros expect.">get_log_component()</a> public accessors.  <a href="classflow_1_1log_1_1Log__context.html#details">More...</a><br /></td></tr>
<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table><table class="memberdecls">
<tr class="heading"><td colspan="2"><h2 class="groupheader"><a id="namespaces" name="namespaces"></a>
Namespaces</h2></td></tr>
<tr class="memitem:namespaceflow"><td class="memItemLeft" align="right" valign="top">namespace &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="namespaceflow.html">flow</a></td></tr>
<tr class="memdesc:namespaceflow"><td class="mdescLeft">&#160;</td><td class="mdescRight">Catch-all namespace for the Flow project: A collection of various production-quality modules written in modern C++17, originally by ygoldfel. <br /></td></tr>
<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:namespaceflow_1_1log"><td class="memItemLeft" align="right" valign="top">namespace &#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="namespaceflow_1_1log.html">flow::log</a></td></tr>
<tr class="memdesc:namespaceflow_1_1log"><td class="mdescLeft">&#160;</td><td class="mdescRight">Flow module providing logging functionality. <br /></td></tr>
<tr class="separator:"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table><table class="memberdecls">
<tr class="heading"><td colspan="2"><h2 class="groupheader"><a id="define-members" name="define-members"></a>
Macros</h2></td></tr>
<tr class="memitem:a626c7dc4d3b4dc0b32a8aac8624d66bc"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="log_8hpp.html#a626c7dc4d3b4dc0b32a8aac8624d66bc">FLOW_LOG_WARNING</a>(ARG_stream_fragment)&#160;&#160;&#160;  <a class="el" href="log_8hpp.html#a692bbadd8b5c3e9cef7a0bbea1915e66">FLOW_LOG_WITH_CHECKING</a>(::flow::log::Sev::S_WARNING, ARG_stream_fragment)</td></tr>
<tr class="memdesc:a626c7dc4d3b4dc0b32a8aac8624d66bc"><td class="mdescLeft">&#160;</td><td class="mdescRight">Logs a WARNING message into <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a> <code>*get_logger()</code> with <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">flow::log::Component</a> <code>get_log_component()</code>, if such logging is enabled by that <code>Logger</code>.  <a href="log_8hpp.html#a626c7dc4d3b4dc0b32a8aac8624d66bc">More...</a><br /></td></tr>
<tr class="separator:a626c7dc4d3b4dc0b32a8aac8624d66bc"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a86c9eda3c93618933d751b675bdbefa5"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="log_8hpp.html#a86c9eda3c93618933d751b675bdbefa5">FLOW_LOG_FATAL</a>(ARG_stream_fragment)&#160;&#160;&#160;  <a class="el" href="log_8hpp.html#a692bbadd8b5c3e9cef7a0bbea1915e66">FLOW_LOG_WITH_CHECKING</a>(::flow::log::Sev::S_FATAL, ARG_stream_fragment)</td></tr>
<tr class="memdesc:a86c9eda3c93618933d751b675bdbefa5"><td class="mdescLeft">&#160;</td><td class="mdescRight">Logs a FATAL message into <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a> <code>*get_logger()</code> with <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">flow::log::Component</a> <code>get_log_component()</code>, if such logging is enabled by the <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a>.  <a href="log_8hpp.html#a86c9eda3c93618933d751b675bdbefa5">More...</a><br /></td></tr>
<tr class="separator:a86c9eda3c93618933d751b675bdbefa5"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a9c1538676a14220c9a04f3480751eb54"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="log_8hpp.html#a9c1538676a14220c9a04f3480751eb54">FLOW_LOG_ERROR</a>(ARG_stream_fragment)&#160;&#160;&#160;  <a class="el" href="log_8hpp.html#a692bbadd8b5c3e9cef7a0bbea1915e66">FLOW_LOG_WITH_CHECKING</a>(::flow::log::Sev::S_ERROR, ARG_stream_fragment)</td></tr>
<tr class="memdesc:a9c1538676a14220c9a04f3480751eb54"><td class="mdescLeft">&#160;</td><td class="mdescRight">Logs an ERROR message into <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a> <code>*get_logger()</code> with <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">flow::log::Component</a> <code>get_log_component()</code>, if such logging is enabled by the <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a>.  <a href="log_8hpp.html#a9c1538676a14220c9a04f3480751eb54">More...</a><br /></td></tr>
<tr class="separator:a9c1538676a14220c9a04f3480751eb54"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a325fdd4b5cf0be49b37d3b7b7c29070d"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="log_8hpp.html#a325fdd4b5cf0be49b37d3b7b7c29070d">FLOW_LOG_INFO</a>(ARG_stream_fragment)&#160;&#160;&#160;  <a class="el" href="log_8hpp.html#a692bbadd8b5c3e9cef7a0bbea1915e66">FLOW_LOG_WITH_CHECKING</a>(::flow::log::Sev::S_INFO, ARG_stream_fragment)</td></tr>
<tr class="memdesc:a325fdd4b5cf0be49b37d3b7b7c29070d"><td class="mdescLeft">&#160;</td><td class="mdescRight">Logs an INFO message into <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a> <code>*get_logger()</code> with <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">flow::log::Component</a> <code>get_log_component()</code>, if such logging is enabled by the <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a>.  <a href="log_8hpp.html#a325fdd4b5cf0be49b37d3b7b7c29070d">More...</a><br /></td></tr>
<tr class="separator:a325fdd4b5cf0be49b37d3b7b7c29070d"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a89710ddaee7323e168aa3587b66c6f90"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="log_8hpp.html#a89710ddaee7323e168aa3587b66c6f90">FLOW_LOG_DEBUG</a>(ARG_stream_fragment)&#160;&#160;&#160;  <a class="el" href="log_8hpp.html#a692bbadd8b5c3e9cef7a0bbea1915e66">FLOW_LOG_WITH_CHECKING</a>(::flow::log::Sev::S_DEBUG, ARG_stream_fragment)</td></tr>
<tr class="memdesc:a89710ddaee7323e168aa3587b66c6f90"><td class="mdescLeft">&#160;</td><td class="mdescRight">Logs a DEBUG message into <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a> <code>*get_logger()</code> with <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">flow::log::Component</a> <code>get_log_component()</code>, if such logging is enabled by the <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a>.  <a href="log_8hpp.html#a89710ddaee7323e168aa3587b66c6f90">More...</a><br /></td></tr>
<tr class="separator:a89710ddaee7323e168aa3587b66c6f90"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:affcf2e4c496ce3f42adf981669c623b8"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="log_8hpp.html#affcf2e4c496ce3f42adf981669c623b8">FLOW_LOG_TRACE</a>(ARG_stream_fragment)&#160;&#160;&#160;  <a class="el" href="log_8hpp.html#a692bbadd8b5c3e9cef7a0bbea1915e66">FLOW_LOG_WITH_CHECKING</a>(::flow::log::Sev::S_TRACE, ARG_stream_fragment)</td></tr>
<tr class="memdesc:affcf2e4c496ce3f42adf981669c623b8"><td class="mdescLeft">&#160;</td><td class="mdescRight">Logs a TRACE message into <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a> <code>*get_logger()</code> with <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">flow::log::Component</a> <code>get_log_component()</code>, if such logging is enabled by the <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a>.  <a href="log_8hpp.html#affcf2e4c496ce3f42adf981669c623b8">More...</a><br /></td></tr>
<tr class="separator:affcf2e4c496ce3f42adf981669c623b8"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a07561c1c3f16b6c2c7335a09e25298c9"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="log_8hpp.html#a07561c1c3f16b6c2c7335a09e25298c9">FLOW_LOG_DATA</a>(ARG_stream_fragment)&#160;&#160;&#160;  <a class="el" href="log_8hpp.html#a692bbadd8b5c3e9cef7a0bbea1915e66">FLOW_LOG_WITH_CHECKING</a>(::flow::log::Sev::S_DATA, ARG_stream_fragment)</td></tr>
<tr class="memdesc:a07561c1c3f16b6c2c7335a09e25298c9"><td class="mdescLeft">&#160;</td><td class="mdescRight">Logs a DATA message into <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a> <code>*get_logger()</code> with <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">flow::log::Component</a> <code>get_log_component()</code>, if such logging is enabled by the <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a>.  <a href="log_8hpp.html#a07561c1c3f16b6c2c7335a09e25298c9">More...</a><br /></td></tr>
<tr class="separator:a07561c1c3f16b6c2c7335a09e25298c9"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a1bd954e4451fd00d23dec6b85ef15774"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="log_8hpp.html#a1bd954e4451fd00d23dec6b85ef15774">FLOW_LOG_WARNING_WITHOUT_CHECKING</a>(ARG_stream_fragment)&#160;&#160;&#160;  <a class="el" href="log_8hpp.html#a5daa2b6d16edea74bb8bddc75f7fb801">FLOW_LOG_WITHOUT_CHECKING</a>(::flow::log::Sev::S_WARNING, ARG_stream_fragment)</td></tr>
<tr class="memdesc:a1bd954e4451fd00d23dec6b85ef15774"><td class="mdescLeft">&#160;</td><td class="mdescRight">Logs a WARNING message into <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a> <code>*get_logger()</code> with <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">flow::log::Component</a> <code>get_log_component()</code> regardless of whether such logging is enabled by the <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a>.  <a href="log_8hpp.html#a1bd954e4451fd00d23dec6b85ef15774">More...</a><br /></td></tr>
<tr class="separator:a1bd954e4451fd00d23dec6b85ef15774"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a5f2f44cddf64eadacb704e6cc592a635"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="log_8hpp.html#a5f2f44cddf64eadacb704e6cc592a635">FLOW_LOG_FATAL_WITHOUT_CHECKING</a>(ARG_stream_fragment)&#160;&#160;&#160;  <a class="el" href="log_8hpp.html#a5daa2b6d16edea74bb8bddc75f7fb801">FLOW_LOG_WITHOUT_CHECKING</a>(::flow::log::Sev::S_FATAL, ARG_stream_fragment)</td></tr>
<tr class="memdesc:a5f2f44cddf64eadacb704e6cc592a635"><td class="mdescLeft">&#160;</td><td class="mdescRight">Logs a FATAL message into <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a> <code>*get_logger()</code> with <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">flow::log::Component</a> <code>get_log_component()</code> regardless of whether such logging is enabled by the <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a>.  <a href="log_8hpp.html#a5f2f44cddf64eadacb704e6cc592a635">More...</a><br /></td></tr>
<tr class="separator:a5f2f44cddf64eadacb704e6cc592a635"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a68153bafb54dcce136b9394738402133"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="log_8hpp.html#a68153bafb54dcce136b9394738402133">FLOW_LOG_ERROR_WITHOUT_CHECKING</a>(ARG_stream_fragment)&#160;&#160;&#160;  <a class="el" href="log_8hpp.html#a5daa2b6d16edea74bb8bddc75f7fb801">FLOW_LOG_WITHOUT_CHECKING</a>(::flow::log::Sev::S_ERROR, ARG_stream_fragment)</td></tr>
<tr class="memdesc:a68153bafb54dcce136b9394738402133"><td class="mdescLeft">&#160;</td><td class="mdescRight">Logs an ERROR message into <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a> <code>*get_logger()</code> with <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">flow::log::Component</a> <code>get_log_component()</code> regardless of whether such logging is enabled by the <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a>.  <a href="log_8hpp.html#a68153bafb54dcce136b9394738402133">More...</a><br /></td></tr>
<tr class="separator:a68153bafb54dcce136b9394738402133"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a1be182a498bd3703311820fec76d04ff"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="log_8hpp.html#a1be182a498bd3703311820fec76d04ff">FLOW_LOG_INFO_WITHOUT_CHECKING</a>(ARG_stream_fragment)&#160;&#160;&#160;  <a class="el" href="log_8hpp.html#a5daa2b6d16edea74bb8bddc75f7fb801">FLOW_LOG_WITHOUT_CHECKING</a>(::flow::log::Sev::S_INFO, ARG_stream_fragment)</td></tr>
<tr class="memdesc:a1be182a498bd3703311820fec76d04ff"><td class="mdescLeft">&#160;</td><td class="mdescRight">Logs an INFO message into <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a> <code>*get_logger()</code> with <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">flow::log::Component</a> <code>get_log_component()</code> regardless of whether such logging is enabled by the <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a>.  <a href="log_8hpp.html#a1be182a498bd3703311820fec76d04ff">More...</a><br /></td></tr>
<tr class="separator:a1be182a498bd3703311820fec76d04ff"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ad3e7f5705279c17e1e22c2427c216d7c"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="log_8hpp.html#ad3e7f5705279c17e1e22c2427c216d7c">FLOW_LOG_DEBUG_WITHOUT_CHECKING</a>(ARG_stream_fragment)&#160;&#160;&#160;  <a class="el" href="log_8hpp.html#a5daa2b6d16edea74bb8bddc75f7fb801">FLOW_LOG_WITHOUT_CHECKING</a>(::flow::log::Sev::S_DEBUG, ARG_stream_fragment)</td></tr>
<tr class="memdesc:ad3e7f5705279c17e1e22c2427c216d7c"><td class="mdescLeft">&#160;</td><td class="mdescRight">Logs a DEBUG message into <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a> <code>*get_logger()</code> with <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">flow::log::Component</a> <code>get_log_component()</code> regardless of whether such logging is enabled by the <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a>.  <a href="log_8hpp.html#ad3e7f5705279c17e1e22c2427c216d7c">More...</a><br /></td></tr>
<tr class="separator:ad3e7f5705279c17e1e22c2427c216d7c"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a6b3b2cd7ddabf90a7c6ccd104a042cc6"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="log_8hpp.html#a6b3b2cd7ddabf90a7c6ccd104a042cc6">FLOW_LOG_TRACE_WITHOUT_CHECKING</a>(ARG_stream_fragment)&#160;&#160;&#160;  <a class="el" href="log_8hpp.html#a5daa2b6d16edea74bb8bddc75f7fb801">FLOW_LOG_WITHOUT_CHECKING</a>(::flow::log::Sev::S_TRACE, ARG_stream_fragment)</td></tr>
<tr class="memdesc:a6b3b2cd7ddabf90a7c6ccd104a042cc6"><td class="mdescLeft">&#160;</td><td class="mdescRight">Logs a TRACE message into <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a> <code>*get_logger()</code> with <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">flow::log::Component</a> <code>get_log_component()</code> regardless of whether such logging is enabled by the <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a>.  <a href="log_8hpp.html#a6b3b2cd7ddabf90a7c6ccd104a042cc6">More...</a><br /></td></tr>
<tr class="separator:a6b3b2cd7ddabf90a7c6ccd104a042cc6"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a9aa1d91ba9eb26345d4b83588ac489cb"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="log_8hpp.html#a9aa1d91ba9eb26345d4b83588ac489cb">FLOW_LOG_DATA_WITHOUT_CHECKING</a>(ARG_stream_fragment)&#160;&#160;&#160;  <a class="el" href="log_8hpp.html#a5daa2b6d16edea74bb8bddc75f7fb801">FLOW_LOG_WITHOUT_CHECKING</a>(::flow::log::Sev::S_DATA, ARG_stream_fragment)</td></tr>
<tr class="memdesc:a9aa1d91ba9eb26345d4b83588ac489cb"><td class="mdescLeft">&#160;</td><td class="mdescRight">Logs a DATA message into <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a> <code>*get_logger()</code> with <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">flow::log::Component</a> <code>get_log_component()</code> regardless of whether such logging is enabled by the <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a>.  <a href="log_8hpp.html#a9aa1d91ba9eb26345d4b83588ac489cb">More...</a><br /></td></tr>
<tr class="separator:a9aa1d91ba9eb26345d4b83588ac489cb"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ae4b5d4fdd2eb052615620879dd74af95"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="log_8hpp.html#ae4b5d4fdd2eb052615620879dd74af95">FLOW_LOG_SET_CONTEXT</a>(ARG_logger_ptr,  ARG_component_payload)</td></tr>
<tr class="memdesc:ae4b5d4fdd2eb052615620879dd74af95"><td class="mdescLeft">&#160;</td><td class="mdescRight">For the rest of the block within which this macro is instantiated, causes all <code>FLOW_LOG_...()</code> invocations to log to <code>ARG_logger_ptr</code> with component <code><a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">flow::log::Component(ARG_component_payload)</a></code>, instead of the normal <code>get_logger()</code> and <code>get_log_component()</code>, if there even such things are available in the block.  <a href="log_8hpp.html#ae4b5d4fdd2eb052615620879dd74af95">More...</a><br /></td></tr>
<tr class="separator:ae4b5d4fdd2eb052615620879dd74af95"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ad4958fbd8673f48be76bf8e5e11d0522"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="log_8hpp.html#ad4958fbd8673f48be76bf8e5e11d0522">FLOW_LOG_SET_LOGGER</a>(ARG_logger_ptr)</td></tr>
<tr class="memdesc:ad4958fbd8673f48be76bf8e5e11d0522"><td class="mdescLeft">&#160;</td><td class="mdescRight">Equivalent to <a class="el" href="log_8hpp.html#ae4b5d4fdd2eb052615620879dd74af95" title="For the rest of the block within which this macro is instantiated, causes all FLOW_LOG_....">FLOW_LOG_SET_CONTEXT()</a> but sets the <code>get_logger</code> only.  <a href="log_8hpp.html#ad4958fbd8673f48be76bf8e5e11d0522">More...</a><br /></td></tr>
<tr class="separator:ad4958fbd8673f48be76bf8e5e11d0522"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a3105444b58d309b7aa9847ea045bd42d"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="log_8hpp.html#a3105444b58d309b7aa9847ea045bd42d">FLOW_LOG_SET_COMPONENT</a>(ARG_component_payload)</td></tr>
<tr class="memdesc:a3105444b58d309b7aa9847ea045bd42d"><td class="mdescLeft">&#160;</td><td class="mdescRight">Equivalent to <a class="el" href="log_8hpp.html#ae4b5d4fdd2eb052615620879dd74af95" title="For the rest of the block within which this macro is instantiated, causes all FLOW_LOG_....">FLOW_LOG_SET_CONTEXT()</a> but sets the <code>get_log_component</code> only.  <a href="log_8hpp.html#a3105444b58d309b7aa9847ea045bd42d">More...</a><br /></td></tr>
<tr class="separator:a3105444b58d309b7aa9847ea045bd42d"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a692bbadd8b5c3e9cef7a0bbea1915e66"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="log_8hpp.html#a692bbadd8b5c3e9cef7a0bbea1915e66">FLOW_LOG_WITH_CHECKING</a>(ARG_sev,  ARG_stream_fragment)</td></tr>
<tr class="memdesc:a692bbadd8b5c3e9cef7a0bbea1915e66"><td class="mdescLeft">&#160;</td><td class="mdescRight">Logs a message of the specified severity into <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a> <code>*get_logger()</code> with <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">flow::log::Component</a> <code>get_log_component()</code> if such logging is enabled by said <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a>.  <a href="log_8hpp.html#a692bbadd8b5c3e9cef7a0bbea1915e66">More...</a><br /></td></tr>
<tr class="separator:a692bbadd8b5c3e9cef7a0bbea1915e66"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:a5daa2b6d16edea74bb8bddc75f7fb801"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="log_8hpp.html#a5daa2b6d16edea74bb8bddc75f7fb801">FLOW_LOG_WITHOUT_CHECKING</a>(ARG_sev,  ARG_stream_fragment)</td></tr>
<tr class="memdesc:a5daa2b6d16edea74bb8bddc75f7fb801"><td class="mdescLeft">&#160;</td><td class="mdescRight">Identical to <a class="el" href="log_8hpp.html#a692bbadd8b5c3e9cef7a0bbea1915e66" title="Logs a message of the specified severity into flow::log::Logger *get_logger() with flow::log::Compone...">FLOW_LOG_WITH_CHECKING()</a> but foregoes the filter (Logger::should_log()) check.  <a href="log_8hpp.html#a5daa2b6d16edea74bb8bddc75f7fb801">More...</a><br /></td></tr>
<tr class="separator:a5daa2b6d16edea74bb8bddc75f7fb801"><td class="memSeparator" colspan="2">&#160;</td></tr>
<tr class="memitem:ab07c4bca2d59872736d0d9717b05aeb1"><td class="memItemLeft" align="right" valign="top">#define&#160;</td><td class="memItemRight" valign="bottom"><a class="el" href="log_8hpp.html#ab07c4bca2d59872736d0d9717b05aeb1">FLOW_LOG_DO_LOG</a>(ARG_logger_ptr,  ARG_component,  ARG_sev,  ARG_file_view,  ARG_line,  ARG_func_view,  ARG_time_stamp,  ARG_call_thread_nickname_str_moved,  ARG_call_thread_id,  ARG_stream_fragment)</td></tr>
<tr class="memdesc:ab07c4bca2d59872736d0d9717b05aeb1"><td class="mdescLeft">&#160;</td><td class="mdescRight">Lowest-level logging API accessible to the user, this is identical to <a class="el" href="log_8hpp.html#a5daa2b6d16edea74bb8bddc75f7fb801" title="Identical to FLOW_LOG_WITH_CHECKING() but foregoes the filter (Logger::should_log()) check.">FLOW_LOG_WITHOUT_CHECKING()</a> but expects all pieces of metadata in addition to the message and log::Sev, plus the <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a>, to be supplied as macro arguments.  <a href="log_8hpp.html#ab07c4bca2d59872736d0d9717b05aeb1">More...</a><br /></td></tr>
<tr class="separator:ab07c4bca2d59872736d0d9717b05aeb1"><td class="memSeparator" colspan="2">&#160;</td></tr>
</table>
<h2 class="groupheader">Macro Definition Documentation</h2>
<a id="a07561c1c3f16b6c2c7335a09e25298c9" name="a07561c1c3f16b6c2c7335a09e25298c9"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a07561c1c3f16b6c2c7335a09e25298c9">&#9670;&nbsp;</a></span>FLOW_LOG_DATA</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">#define FLOW_LOG_DATA</td>
          <td>(</td>
          <td class="paramtype">&#160;</td>
          <td class="paramname">ARG_stream_fragment</td><td>)</td>
          <td>&#160;&#160;&#160;  <a class="el" href="log_8hpp.html#a692bbadd8b5c3e9cef7a0bbea1915e66">FLOW_LOG_WITH_CHECKING</a>(::flow::log::Sev::S_DATA, ARG_stream_fragment)</td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Logs a DATA message into <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a> <code>*get_logger()</code> with <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">flow::log::Component</a> <code>get_log_component()</code>, if such logging is enabled by the <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a>. </p>
<p >Analogous to <a class="el" href="log_8hpp.html#a626c7dc4d3b4dc0b32a8aac8624d66bc" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING()</a> but for the <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a138fe9b2eb78ab00c84b21c4a6b48fed" title="Message satisfies Sev::S_TRACE description AND contains variable-length structure (like packet,...">flow::log::Sev::S_DATA</a> severity.</p>
<h3>Severity selection</h3>
<p >Before selecting a severity for your log call site, please consider the discussion in the <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">flow::log::Sev</a> doc header.</p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">ARG_stream_fragment</td><td>Same as in <a class="el" href="log_8hpp.html#a626c7dc4d3b4dc0b32a8aac8624d66bc" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING()</a>. </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a id="a9aa1d91ba9eb26345d4b83588ac489cb" name="a9aa1d91ba9eb26345d4b83588ac489cb"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a9aa1d91ba9eb26345d4b83588ac489cb">&#9670;&nbsp;</a></span>FLOW_LOG_DATA_WITHOUT_CHECKING</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">#define FLOW_LOG_DATA_WITHOUT_CHECKING</td>
          <td>(</td>
          <td class="paramtype">&#160;</td>
          <td class="paramname">ARG_stream_fragment</td><td>)</td>
          <td>&#160;&#160;&#160;  <a class="el" href="log_8hpp.html#a5daa2b6d16edea74bb8bddc75f7fb801">FLOW_LOG_WITHOUT_CHECKING</a>(::flow::log::Sev::S_DATA, ARG_stream_fragment)</td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Logs a DATA message into <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a> <code>*get_logger()</code> with <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">flow::log::Component</a> <code>get_log_component()</code> regardless of whether such logging is enabled by the <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a>. </p>
<p >Analogous to <a class="el" href="log_8hpp.html#a1bd954e4451fd00d23dec6b85ef15774" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING_WITHOUT_CHECKING()</a> but for the <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a138fe9b2eb78ab00c84b21c4a6b48fed" title="Message satisfies Sev::S_TRACE description AND contains variable-length structure (like packet,...">flow::log::Sev::S_DATA</a> severity.</p>
<dl class="section note"><dt>Note</dt><dd>Same warnings and notes as for <a class="el" href="log_8hpp.html#a1bd954e4451fd00d23dec6b85ef15774" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING_WITHOUT_CHECKING()</a>.</dd></dl>
<h3>Severity selection</h3>
<p >Before selecting a severity for your log call site, please consider the discussion in the <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">flow::log::Sev</a> doc header.</p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">ARG_stream_fragment</td><td>Same as in <a class="el" href="log_8hpp.html#a626c7dc4d3b4dc0b32a8aac8624d66bc" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING()</a>. </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a id="a89710ddaee7323e168aa3587b66c6f90" name="a89710ddaee7323e168aa3587b66c6f90"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a89710ddaee7323e168aa3587b66c6f90">&#9670;&nbsp;</a></span>FLOW_LOG_DEBUG</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">#define FLOW_LOG_DEBUG</td>
          <td>(</td>
          <td class="paramtype">&#160;</td>
          <td class="paramname">ARG_stream_fragment</td><td>)</td>
          <td>&#160;&#160;&#160;  <a class="el" href="log_8hpp.html#a692bbadd8b5c3e9cef7a0bbea1915e66">FLOW_LOG_WITH_CHECKING</a>(::flow::log::Sev::S_DEBUG, ARG_stream_fragment)</td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Logs a DEBUG message into <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a> <code>*get_logger()</code> with <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">flow::log::Component</a> <code>get_log_component()</code>, if such logging is enabled by the <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a>. </p>
<p >Analogous to <a class="el" href="log_8hpp.html#a626c7dc4d3b4dc0b32a8aac8624d66bc" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING()</a> but for the <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04aa6874010df179b46ffec47aaf9bc1358" title="Message indicates a condition with, perhaps, no significant perf impact if enabled (like Sev::S_INFO)...">flow::log::Sev::S_DEBUG</a> severity.</p>
<h3>Severity selection</h3>
<p >Before selecting a severity for your log call site, please consider the discussion in the <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">flow::log::Sev</a> doc header.</p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">ARG_stream_fragment</td><td>Same as in <a class="el" href="log_8hpp.html#a626c7dc4d3b4dc0b32a8aac8624d66bc" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING()</a>. </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a id="ad3e7f5705279c17e1e22c2427c216d7c" name="ad3e7f5705279c17e1e22c2427c216d7c"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ad3e7f5705279c17e1e22c2427c216d7c">&#9670;&nbsp;</a></span>FLOW_LOG_DEBUG_WITHOUT_CHECKING</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">#define FLOW_LOG_DEBUG_WITHOUT_CHECKING</td>
          <td>(</td>
          <td class="paramtype">&#160;</td>
          <td class="paramname">ARG_stream_fragment</td><td>)</td>
          <td>&#160;&#160;&#160;  <a class="el" href="log_8hpp.html#a5daa2b6d16edea74bb8bddc75f7fb801">FLOW_LOG_WITHOUT_CHECKING</a>(::flow::log::Sev::S_DEBUG, ARG_stream_fragment)</td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Logs a DEBUG message into <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a> <code>*get_logger()</code> with <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">flow::log::Component</a> <code>get_log_component()</code> regardless of whether such logging is enabled by the <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a>. </p>
<p >Analogous to <a class="el" href="log_8hpp.html#a1bd954e4451fd00d23dec6b85ef15774" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING_WITHOUT_CHECKING()</a> but for the <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04aa6874010df179b46ffec47aaf9bc1358" title="Message indicates a condition with, perhaps, no significant perf impact if enabled (like Sev::S_INFO)...">flow::log::Sev::S_DEBUG</a> severity.</p>
<dl class="section note"><dt>Note</dt><dd>Same warnings and notes as for <a class="el" href="log_8hpp.html#a1bd954e4451fd00d23dec6b85ef15774" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING_WITHOUT_CHECKING()</a>.</dd></dl>
<h3>Severity selection</h3>
<p >Before selecting a severity for your log call site, please consider the discussion in the <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">flow::log::Sev</a> doc header.</p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">ARG_stream_fragment</td><td>Same as in <a class="el" href="log_8hpp.html#a626c7dc4d3b4dc0b32a8aac8624d66bc" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING()</a>. </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a id="ab07c4bca2d59872736d0d9717b05aeb1" name="ab07c4bca2d59872736d0d9717b05aeb1"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ab07c4bca2d59872736d0d9717b05aeb1">&#9670;&nbsp;</a></span>FLOW_LOG_DO_LOG</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">#define FLOW_LOG_DO_LOG</td>
          <td>(</td>
          <td class="paramtype">&#160;</td>
          <td class="paramname">ARG_logger_ptr, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">&#160;</td>
          <td class="paramname">ARG_component, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">&#160;</td>
          <td class="paramname">ARG_sev, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">&#160;</td>
          <td class="paramname">ARG_file_view, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">&#160;</td>
          <td class="paramname">ARG_line, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">&#160;</td>
          <td class="paramname">ARG_func_view, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">&#160;</td>
          <td class="paramname">ARG_time_stamp, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">&#160;</td>
          <td class="paramname">ARG_call_thread_nickname_str_moved, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">&#160;</td>
          <td class="paramname">ARG_call_thread_id, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">&#160;</td>
          <td class="paramname">ARG_stream_fragment&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Lowest-level logging API accessible to the user, this is identical to <a class="el" href="log_8hpp.html#a5daa2b6d16edea74bb8bddc75f7fb801" title="Identical to FLOW_LOG_WITH_CHECKING() but foregoes the filter (Logger::should_log()) check.">FLOW_LOG_WITHOUT_CHECKING()</a> but expects all pieces of metadata in addition to the message and log::Sev, plus the <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a>, to be supplied as macro arguments. </p>
<p >Internally, all other log-call-site macros ultimately build on top of this one.</p>
<dl class="section note"><dt>Note</dt><dd>From public user's point of view: It's <a class="el" href="classflow_1_1log_1_1Logger.html#ac8a2e7a33fe3fbc0c29ead62ed98c022" title="Given attributes of a hypothetical message that would be logged, return true if that message should b...">flow::log::Logger::should_log()</a> that allows the message argument to be built using <code>ostream&lt;&lt;</code> semantics instead of having to instantiate an intermediate <a class="el" href="classflow_1_1util_1_1String__ostream.html" title="Similar to ostringstream but allows fast read-only access directly into the std::string being written...">flow::util::String_ostream</a> (which has performance overhead and is more verbose). Why not just use a higher-level macro &ndash; at least as high-level as <a class="el" href="log_8hpp.html#a5daa2b6d16edea74bb8bddc75f7fb801" title="Identical to FLOW_LOG_WITH_CHECKING() but foregoes the filter (Logger::should_log()) check.">FLOW_LOG_WITHOUT_CHECKING()</a> &ndash; instead? Answer: In some cases there is a source of metadata, like file and line number, that comes from a different source than (e.g.) <code>__FILE__</code> and <code>__LINE__</code> at the log call site; e.g., when logging from another log API through <a class="el" href="namespaceflow_1_1log.html" title="Flow module providing logging functionality.">flow::log</a>.</dd></dl>
<dl class="section warning"><dt>Warning</dt><dd>If invoking this directly, API user must manually ensure the severity/component is enabled in the <code>Logger</code>. Not doing so breaks (unenforced but nevertheless mandatory) rules of logging system. </dd>
<dd>
If invoking this directly, API user must manually ensure <code>ARG_logger_ptr</code> is not null. Otherwise behavior is undefined.</dd></dl>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">ARG_logger_ptr</td><td>A <code>Logger*</code> through which to log; not null. </td></tr>
    <tr><td class="paramname">ARG_component</td><td>See Msg_metadata (reference copied into it). </td></tr>
    <tr><td class="paramname">ARG_sev</td><td>See Msg_metadata (<code>enum</code> value copied into it). </td></tr>
    <tr><td class="paramname">ARG_file_view</td><td>See Msg_metadata (<code>String_view</code> copied into it). Reminder: Underlying memory may need to remain valid asynchronously (read: indefinitely); usually it's a literal in static storage. </td></tr>
    <tr><td class="paramname">ARG_line</td><td>See Msg_metadata (integer copied into it). </td></tr>
    <tr><td class="paramname">ARG_func_view</td><td>See Msg_metadata (<code>String_view</code> copied into it). Reminder: Same as for <code>ARG_file_view</code>. </td></tr>
    <tr><td class="paramname">ARG_time_stamp</td><td>See Msg_metadata (scalar copied into it). </td></tr>
    <tr><td class="paramname">ARG_call_thread_nickname_str_moved</td><td>See Msg_metadata (this <code>std::string</code> is <em>moved</em> into it and thus made empty). </td></tr>
    <tr><td class="paramname">ARG_call_thread_id</td><td>See Msg_metadata (scalar copied into it). </td></tr>
    <tr><td class="paramname">ARG_stream_fragment</td><td>See <a class="el" href="log_8hpp.html#a5daa2b6d16edea74bb8bddc75f7fb801" title="Identical to FLOW_LOG_WITH_CHECKING() but foregoes the filter (Logger::should_log()) check.">FLOW_LOG_WITHOUT_CHECKING()</a>. </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a id="a9c1538676a14220c9a04f3480751eb54" name="a9c1538676a14220c9a04f3480751eb54"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a9c1538676a14220c9a04f3480751eb54">&#9670;&nbsp;</a></span>FLOW_LOG_ERROR</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">#define FLOW_LOG_ERROR</td>
          <td>(</td>
          <td class="paramtype">&#160;</td>
          <td class="paramname">ARG_stream_fragment</td><td>)</td>
          <td>&#160;&#160;&#160;  <a class="el" href="log_8hpp.html#a692bbadd8b5c3e9cef7a0bbea1915e66">FLOW_LOG_WITH_CHECKING</a>(::flow::log::Sev::S_ERROR, ARG_stream_fragment)</td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Logs an ERROR message into <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a> <code>*get_logger()</code> with <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">flow::log::Component</a> <code>get_log_component()</code>, if such logging is enabled by the <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a>. </p>
<p >Analogous to <a class="el" href="log_8hpp.html#a626c7dc4d3b4dc0b32a8aac8624d66bc" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING()</a> but for the <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04aac04e40d3b2f54f1f517d49594eb7849" title="Message indicates a &quot;bad&quot; condition with &quot;worse&quot; impact than that of Sev::S_WARNING.">flow::log::Sev::S_ERROR</a> severity.</p>
<h3>Severity selection</h3>
<p >Before selecting a severity for your log call site, please consider the discussion in the <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">flow::log::Sev</a> doc header.</p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">ARG_stream_fragment</td><td>Same as in <a class="el" href="log_8hpp.html#a626c7dc4d3b4dc0b32a8aac8624d66bc" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING()</a>. </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a id="a68153bafb54dcce136b9394738402133" name="a68153bafb54dcce136b9394738402133"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a68153bafb54dcce136b9394738402133">&#9670;&nbsp;</a></span>FLOW_LOG_ERROR_WITHOUT_CHECKING</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">#define FLOW_LOG_ERROR_WITHOUT_CHECKING</td>
          <td>(</td>
          <td class="paramtype">&#160;</td>
          <td class="paramname">ARG_stream_fragment</td><td>)</td>
          <td>&#160;&#160;&#160;  <a class="el" href="log_8hpp.html#a5daa2b6d16edea74bb8bddc75f7fb801">FLOW_LOG_WITHOUT_CHECKING</a>(::flow::log::Sev::S_ERROR, ARG_stream_fragment)</td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Logs an ERROR message into <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a> <code>*get_logger()</code> with <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">flow::log::Component</a> <code>get_log_component()</code> regardless of whether such logging is enabled by the <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a>. </p>
<p >Analogous to <a class="el" href="log_8hpp.html#a1bd954e4451fd00d23dec6b85ef15774" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING_WITHOUT_CHECKING()</a> but for the <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04aac04e40d3b2f54f1f517d49594eb7849" title="Message indicates a &quot;bad&quot; condition with &quot;worse&quot; impact than that of Sev::S_WARNING.">flow::log::Sev::S_ERROR</a> severity.</p>
<dl class="section note"><dt>Note</dt><dd>Same warnings and notes as for <a class="el" href="log_8hpp.html#a1bd954e4451fd00d23dec6b85ef15774" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING_WITHOUT_CHECKING()</a>.</dd></dl>
<h3>Severity selection</h3>
<p >Before selecting a severity for your log call site, please consider the discussion in the <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">flow::log::Sev</a> doc header.</p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">ARG_stream_fragment</td><td>Same as in <a class="el" href="log_8hpp.html#a626c7dc4d3b4dc0b32a8aac8624d66bc" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING()</a>. </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a id="a86c9eda3c93618933d751b675bdbefa5" name="a86c9eda3c93618933d751b675bdbefa5"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a86c9eda3c93618933d751b675bdbefa5">&#9670;&nbsp;</a></span>FLOW_LOG_FATAL</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">#define FLOW_LOG_FATAL</td>
          <td>(</td>
          <td class="paramtype">&#160;</td>
          <td class="paramname">ARG_stream_fragment</td><td>)</td>
          <td>&#160;&#160;&#160;  <a class="el" href="log_8hpp.html#a692bbadd8b5c3e9cef7a0bbea1915e66">FLOW_LOG_WITH_CHECKING</a>(::flow::log::Sev::S_FATAL, ARG_stream_fragment)</td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Logs a FATAL message into <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a> <code>*get_logger()</code> with <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">flow::log::Component</a> <code>get_log_component()</code>, if such logging is enabled by the <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a>. </p>
<p >Analogous to <a class="el" href="log_8hpp.html#a626c7dc4d3b4dc0b32a8aac8624d66bc" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING()</a> but for the <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04ac90b5a22c7659cc99e7a6d919a14b660" title="Message indicates a &quot;fatally bad&quot; condition, such that the program shall imminently abort,...">flow::log::Sev::S_FATAL</a> severity.</p>
<h3>Severity selection</h3>
<p >Before selecting a severity for your log call site, please consider the discussion in the <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">flow::log::Sev</a> doc header.</p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">ARG_stream_fragment</td><td>Same as in <a class="el" href="log_8hpp.html#a626c7dc4d3b4dc0b32a8aac8624d66bc" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING()</a>. </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a id="a5f2f44cddf64eadacb704e6cc592a635" name="a5f2f44cddf64eadacb704e6cc592a635"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a5f2f44cddf64eadacb704e6cc592a635">&#9670;&nbsp;</a></span>FLOW_LOG_FATAL_WITHOUT_CHECKING</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">#define FLOW_LOG_FATAL_WITHOUT_CHECKING</td>
          <td>(</td>
          <td class="paramtype">&#160;</td>
          <td class="paramname">ARG_stream_fragment</td><td>)</td>
          <td>&#160;&#160;&#160;  <a class="el" href="log_8hpp.html#a5daa2b6d16edea74bb8bddc75f7fb801">FLOW_LOG_WITHOUT_CHECKING</a>(::flow::log::Sev::S_FATAL, ARG_stream_fragment)</td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Logs a FATAL message into <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a> <code>*get_logger()</code> with <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">flow::log::Component</a> <code>get_log_component()</code> regardless of whether such logging is enabled by the <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a>. </p>
<p >Analogous to <a class="el" href="log_8hpp.html#a1bd954e4451fd00d23dec6b85ef15774" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING_WITHOUT_CHECKING()</a> but for the <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04ac90b5a22c7659cc99e7a6d919a14b660" title="Message indicates a &quot;fatally bad&quot; condition, such that the program shall imminently abort,...">flow::log::Sev::S_FATAL</a> severity.</p>
<dl class="section note"><dt>Note</dt><dd>Same warnings and notes as for <a class="el" href="log_8hpp.html#a1bd954e4451fd00d23dec6b85ef15774" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING_WITHOUT_CHECKING()</a>.</dd></dl>
<h3>Severity selection</h3>
<p >Before selecting a severity for your log call site, please consider the discussion in the <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">flow::log::Sev</a> doc header.</p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">ARG_stream_fragment</td><td>Same as in <a class="el" href="log_8hpp.html#a626c7dc4d3b4dc0b32a8aac8624d66bc" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING()</a>. </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a id="a325fdd4b5cf0be49b37d3b7b7c29070d" name="a325fdd4b5cf0be49b37d3b7b7c29070d"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a325fdd4b5cf0be49b37d3b7b7c29070d">&#9670;&nbsp;</a></span>FLOW_LOG_INFO</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">#define FLOW_LOG_INFO</td>
          <td>(</td>
          <td class="paramtype">&#160;</td>
          <td class="paramname">ARG_stream_fragment</td><td>)</td>
          <td>&#160;&#160;&#160;  <a class="el" href="log_8hpp.html#a692bbadd8b5c3e9cef7a0bbea1915e66">FLOW_LOG_WITH_CHECKING</a>(::flow::log::Sev::S_INFO, ARG_stream_fragment)</td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Logs an INFO message into <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a> <code>*get_logger()</code> with <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">flow::log::Component</a> <code>get_log_component()</code>, if such logging is enabled by the <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a>. </p>
<p >Analogous to <a class="el" href="log_8hpp.html#a626c7dc4d3b4dc0b32a8aac8624d66bc" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING()</a> but for the <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04ac238793326fae17afcc849e96b96e8e7" title="Message indicates a not-&quot;bad&quot; condition that is not frequent enough to be of severity Sev::S_TRACE.">flow::log::Sev::S_INFO</a> severity.</p>
<h3>Severity selection</h3>
<p >Before selecting a severity for your log call site, please consider the discussion in the <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">flow::log::Sev</a> doc header.</p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">ARG_stream_fragment</td><td>Same as in <a class="el" href="log_8hpp.html#a626c7dc4d3b4dc0b32a8aac8624d66bc" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING()</a>. </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a id="a1be182a498bd3703311820fec76d04ff" name="a1be182a498bd3703311820fec76d04ff"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a1be182a498bd3703311820fec76d04ff">&#9670;&nbsp;</a></span>FLOW_LOG_INFO_WITHOUT_CHECKING</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">#define FLOW_LOG_INFO_WITHOUT_CHECKING</td>
          <td>(</td>
          <td class="paramtype">&#160;</td>
          <td class="paramname">ARG_stream_fragment</td><td>)</td>
          <td>&#160;&#160;&#160;  <a class="el" href="log_8hpp.html#a5daa2b6d16edea74bb8bddc75f7fb801">FLOW_LOG_WITHOUT_CHECKING</a>(::flow::log::Sev::S_INFO, ARG_stream_fragment)</td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Logs an INFO message into <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a> <code>*get_logger()</code> with <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">flow::log::Component</a> <code>get_log_component()</code> regardless of whether such logging is enabled by the <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a>. </p>
<p >Analogous to <a class="el" href="log_8hpp.html#a1bd954e4451fd00d23dec6b85ef15774" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING_WITHOUT_CHECKING()</a> but for the <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04ac238793326fae17afcc849e96b96e8e7" title="Message indicates a not-&quot;bad&quot; condition that is not frequent enough to be of severity Sev::S_TRACE.">flow::log::Sev::S_INFO</a> severity.</p>
<dl class="section note"><dt>Note</dt><dd>Same warnings and notes as for <a class="el" href="log_8hpp.html#a1bd954e4451fd00d23dec6b85ef15774" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING_WITHOUT_CHECKING()</a>.</dd></dl>
<h3>Severity selection</h3>
<p >Before selecting a severity for your log call site, please consider the discussion in the <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">flow::log::Sev</a> doc header.</p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">ARG_stream_fragment</td><td>Same as in <a class="el" href="log_8hpp.html#a626c7dc4d3b4dc0b32a8aac8624d66bc" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING()</a>. </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a id="a3105444b58d309b7aa9847ea045bd42d" name="a3105444b58d309b7aa9847ea045bd42d"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a3105444b58d309b7aa9847ea045bd42d">&#9670;&nbsp;</a></span>FLOW_LOG_SET_COMPONENT</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">#define FLOW_LOG_SET_COMPONENT</td>
          <td>(</td>
          <td class="paramtype">&#160;</td>
          <td class="paramname">ARG_component_payload</td><td>)</td>
          <td></td>
        </tr>
      </table>
</div><div class="memdoc">
<b>Value:</b><div class="fragment"><div class="line">  [[maybe_unused]] \</div>
<div class="line">    const <span class="keyword">auto</span> get_log_component = [component = <a class="code hl_class" href="classflow_1_1log_1_1Component.html">::flow::log::Component</a>(ARG_component_payload)] \</div>
<div class="line">                                     () -&gt; const ::flow::log::Component &amp; \</div>
<div class="line">  { \</div>
<div class="line">    return component; \</div>
<div class="line">  }</div>
<div class="ttc" id="aclassflow_1_1log_1_1Component_html"><div class="ttname"><a href="classflow_1_1log_1_1Component.html">flow::log::Component</a></div><div class="ttdoc">A light-weight class, each object storing a component payload encoding an enum value from enum type o...</div><div class="ttdef"><b>Definition:</b> log.hpp:840</div></div>
</div><!-- fragment -->
<p>Equivalent to <a class="el" href="log_8hpp.html#ae4b5d4fdd2eb052615620879dd74af95" title="For the rest of the block within which this macro is instantiated, causes all FLOW_LOG_....">FLOW_LOG_SET_CONTEXT()</a> but sets the <code>get_log_component</code> only. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">ARG_component_payload</td><td>See <a class="el" href="log_8hpp.html#ae4b5d4fdd2eb052615620879dd74af95" title="For the rest of the block within which this macro is instantiated, causes all FLOW_LOG_....">FLOW_LOG_SET_CONTEXT()</a>. </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a id="ae4b5d4fdd2eb052615620879dd74af95" name="ae4b5d4fdd2eb052615620879dd74af95"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ae4b5d4fdd2eb052615620879dd74af95">&#9670;&nbsp;</a></span>FLOW_LOG_SET_CONTEXT</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">#define FLOW_LOG_SET_CONTEXT</td>
          <td>(</td>
          <td class="paramtype">&#160;</td>
          <td class="paramname">ARG_logger_ptr, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">&#160;</td>
          <td class="paramname">ARG_component_payload&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">
<b>Value:</b><div class="fragment"><div class="line">  <a class="code hl_define" href="log_8hpp.html#ad4958fbd8673f48be76bf8e5e11d0522">FLOW_LOG_SET_LOGGER</a>(ARG_logger_ptr); \</div>
<div class="line">  FLOW_LOG_SET_COMPONENT(ARG_component_payload);</div>
<div class="ttc" id="alog_8hpp_html_ad4958fbd8673f48be76bf8e5e11d0522"><div class="ttname"><a href="log_8hpp.html#ad4958fbd8673f48be76bf8e5e11d0522">FLOW_LOG_SET_LOGGER</a></div><div class="ttdeci">#define FLOW_LOG_SET_LOGGER(ARG_logger_ptr)</div><div class="ttdoc">Equivalent to FLOW_LOG_SET_CONTEXT() but sets the get_logger only.</div><div class="ttdef"><b>Definition:</b> log.hpp:415</div></div>
</div><!-- fragment -->
<p>For the rest of the block within which this macro is instantiated, causes all <code>FLOW_LOG_...()</code> invocations to log to <code>ARG_logger_ptr</code> with component <code><a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">flow::log::Component(ARG_component_payload)</a></code>, instead of the normal <code>get_logger()</code> and <code>get_log_component()</code>, if there even such things are available in the block. </p>
<p >This is useful, for example, in <code>static</code> methods, where there is no <code>get_logger()</code> or <code>get_log_component()</code> function defined, but a <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a> and component payload are available (for example) via parameters. It's also useful if one wants to log to a different <code>Logger*</code> for some reason and/or (perhaps more likely) a different component. Note that this creates or changes the meaning of the identifiers <code>get_logger</code> and <code>get_log_component</code> for the rest of the block; in fact you may call <code>get_logger()</code> or <code>get_log_component()</code> directly for whatever nefarious purposes you require, though it is suspected to be rare compared to just using <code>FLOW_LOG_...()</code> normally.</p>
<p >Example: </p><div class="fragment"><div class="line"><span class="comment">// Suppose flow_node is a flow::Node object, which derives from Log_context.</span></div>
<div class="line"><a class="code hl_define" href="log_8hpp.html#ae4b5d4fdd2eb052615620879dd74af95">FLOW_LOG_SET_CONTEXT</a>(flow_node.get_logger(), My_project_components::S_COOL_MODULE);</div>
<div class="line"><span class="comment">// Logs with component S_COOL_MODULE to logger set above.</span></div>
<div class="line"><a class="code hl_define" href="log_8hpp.html#a626c7dc4d3b4dc0b32a8aac8624d66bc">FLOW_LOG_WARNING</a>(<span class="stringliteral">&quot;Something horrible happened: [&quot;</span> &lt;&lt; error_str &lt;&lt; <span class="stringliteral">&quot;].&quot;</span>);</div>
<div class="ttc" id="alog_8hpp_html_a626c7dc4d3b4dc0b32a8aac8624d66bc"><div class="ttname"><a href="log_8hpp.html#a626c7dc4d3b4dc0b32a8aac8624d66bc">FLOW_LOG_WARNING</a></div><div class="ttdeci">#define FLOW_LOG_WARNING(ARG_stream_fragment)</div><div class="ttdoc">Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...</div><div class="ttdef"><b>Definition:</b> log.hpp:152</div></div>
<div class="ttc" id="alog_8hpp_html_ae4b5d4fdd2eb052615620879dd74af95"><div class="ttname"><a href="log_8hpp.html#ae4b5d4fdd2eb052615620879dd74af95">FLOW_LOG_SET_CONTEXT</a></div><div class="ttdeci">#define FLOW_LOG_SET_CONTEXT(ARG_logger_ptr, ARG_component_payload)</div><div class="ttdoc">For the rest of the block within which this macro is instantiated, causes all FLOW_LOG_....</div><div class="ttdef"><b>Definition:</b> log.hpp:405</div></div>
</div><!-- fragment --><dl class="section note"><dt>Note</dt><dd>It will not compile if used 2+ times in the same block at the same nesting level. (The same applies to mixing with <a class="el" href="log_8hpp.html#a3105444b58d309b7aa9847ea045bd42d" title="Equivalent to FLOW_LOG_SET_CONTEXT() but sets the get_log_component only.">FLOW_LOG_SET_COMPONENT()</a> or <a class="el" href="log_8hpp.html#ad4958fbd8673f48be76bf8e5e11d0522" title="Equivalent to FLOW_LOG_SET_CONTEXT() but sets the get_logger only.">FLOW_LOG_SET_LOGGER()</a>.) However, one can create sub-blocks to work around this (likely very infrequent) situation.</dd></dl>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">ARG_logger_ptr</td><td><code>ARG_logger_ptr</code> will be used as the <code>Logger*</code> in subsequent <code>FLOW_LOG_...()</code> invocations in this block. </td></tr>
    <tr><td class="paramname">ARG_component_payload</td><td><code>Component(ARG_component_payload)</code>, a light-weight holder of a copy of <code>ARG_component_payload</code>, will be used as the <code>const Component&amp;</code> in subsequent <code>FLOW_LOG_...()</code> invocations in this block. </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a id="ad4958fbd8673f48be76bf8e5e11d0522" name="ad4958fbd8673f48be76bf8e5e11d0522"></a>
<h2 class="memtitle"><span class="permalink"><a href="#ad4958fbd8673f48be76bf8e5e11d0522">&#9670;&nbsp;</a></span>FLOW_LOG_SET_LOGGER</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">#define FLOW_LOG_SET_LOGGER</td>
          <td>(</td>
          <td class="paramtype">&#160;</td>
          <td class="paramname">ARG_logger_ptr</td><td>)</td>
          <td></td>
        </tr>
      </table>
</div><div class="memdoc">
<b>Value:</b><div class="fragment"><div class="line">  [[maybe_unused]] \</div>
<div class="line">    const <span class="keyword">auto</span> get_logger \</div>
<div class="line">      = [logger_ptr_copy = <span class="keyword">static_cast&lt;</span>::<a class="code hl_class" href="classflow_1_1log_1_1Logger.html">flow::log::Logger</a>*<span class="keyword">&gt;</span>(ARG_logger_ptr)] \</div>
<div class="line">          () -&gt; <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">::flow::log::Logger</a>* { <span class="keywordflow">return</span> logger_ptr_copy; }</div>
<div class="ttc" id="aclassflow_1_1log_1_1Logger_html"><div class="ttname"><a href="classflow_1_1log_1_1Logger.html">flow::log::Logger</a></div><div class="ttdoc">Interface that the user should implement, passing the implementing Logger into logging classes (Flow'...</div><div class="ttdef"><b>Definition:</b> log.hpp:1284</div></div>
</div><!-- fragment -->
<p>Equivalent to <a class="el" href="log_8hpp.html#ae4b5d4fdd2eb052615620879dd74af95" title="For the rest of the block within which this macro is instantiated, causes all FLOW_LOG_....">FLOW_LOG_SET_CONTEXT()</a> but sets the <code>get_logger</code> only. </p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">ARG_logger_ptr</td><td>See <a class="el" href="log_8hpp.html#ae4b5d4fdd2eb052615620879dd74af95" title="For the rest of the block within which this macro is instantiated, causes all FLOW_LOG_....">FLOW_LOG_SET_CONTEXT()</a>. </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a id="affcf2e4c496ce3f42adf981669c623b8" name="affcf2e4c496ce3f42adf981669c623b8"></a>
<h2 class="memtitle"><span class="permalink"><a href="#affcf2e4c496ce3f42adf981669c623b8">&#9670;&nbsp;</a></span>FLOW_LOG_TRACE</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">#define FLOW_LOG_TRACE</td>
          <td>(</td>
          <td class="paramtype">&#160;</td>
          <td class="paramname">ARG_stream_fragment</td><td>)</td>
          <td>&#160;&#160;&#160;  <a class="el" href="log_8hpp.html#a692bbadd8b5c3e9cef7a0bbea1915e66">FLOW_LOG_WITH_CHECKING</a>(::flow::log::Sev::S_TRACE, ARG_stream_fragment)</td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Logs a TRACE message into <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a> <code>*get_logger()</code> with <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">flow::log::Component</a> <code>get_log_component()</code>, if such logging is enabled by the <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a>. </p>
<p >Analogous to <a class="el" href="log_8hpp.html#a626c7dc4d3b4dc0b32a8aac8624d66bc" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING()</a> but for the <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a3ee808b04c34bf6c110e3754de277f7b" title="Message indicates any condition that may occur with great frequency (thus verbose if logged).">flow::log::Sev::S_TRACE</a> severity.</p>
<h3>Severity selection</h3>
<p >Before selecting a severity for your log call site, please consider the discussion in the <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">flow::log::Sev</a> doc header.</p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">ARG_stream_fragment</td><td>Same as in <a class="el" href="log_8hpp.html#a626c7dc4d3b4dc0b32a8aac8624d66bc" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING()</a>. </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a id="a6b3b2cd7ddabf90a7c6ccd104a042cc6" name="a6b3b2cd7ddabf90a7c6ccd104a042cc6"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a6b3b2cd7ddabf90a7c6ccd104a042cc6">&#9670;&nbsp;</a></span>FLOW_LOG_TRACE_WITHOUT_CHECKING</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">#define FLOW_LOG_TRACE_WITHOUT_CHECKING</td>
          <td>(</td>
          <td class="paramtype">&#160;</td>
          <td class="paramname">ARG_stream_fragment</td><td>)</td>
          <td>&#160;&#160;&#160;  <a class="el" href="log_8hpp.html#a5daa2b6d16edea74bb8bddc75f7fb801">FLOW_LOG_WITHOUT_CHECKING</a>(::flow::log::Sev::S_TRACE, ARG_stream_fragment)</td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Logs a TRACE message into <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a> <code>*get_logger()</code> with <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">flow::log::Component</a> <code>get_log_component()</code> regardless of whether such logging is enabled by the <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a>. </p>
<p >Analogous to <a class="el" href="log_8hpp.html#a1bd954e4451fd00d23dec6b85ef15774" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING_WITHOUT_CHECKING()</a> but for the <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a3ee808b04c34bf6c110e3754de277f7b" title="Message indicates any condition that may occur with great frequency (thus verbose if logged).">flow::log::Sev::S_TRACE</a> severity.</p>
<dl class="section note"><dt>Note</dt><dd>Same warnings and notes as for <a class="el" href="log_8hpp.html#a1bd954e4451fd00d23dec6b85ef15774" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING_WITHOUT_CHECKING()</a>.</dd></dl>
<h3>Severity selection</h3>
<p >Before selecting a severity for your log call site, please consider the discussion in the <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">flow::log::Sev</a> doc header.</p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">ARG_stream_fragment</td><td>Same as in <a class="el" href="log_8hpp.html#a626c7dc4d3b4dc0b32a8aac8624d66bc" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING()</a>. </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a id="a626c7dc4d3b4dc0b32a8aac8624d66bc" name="a626c7dc4d3b4dc0b32a8aac8624d66bc"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a626c7dc4d3b4dc0b32a8aac8624d66bc">&#9670;&nbsp;</a></span>FLOW_LOG_WARNING</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">#define FLOW_LOG_WARNING</td>
          <td>(</td>
          <td class="paramtype">&#160;</td>
          <td class="paramname">ARG_stream_fragment</td><td>)</td>
          <td>&#160;&#160;&#160;  <a class="el" href="log_8hpp.html#a692bbadd8b5c3e9cef7a0bbea1915e66">FLOW_LOG_WITH_CHECKING</a>(::flow::log::Sev::S_WARNING, ARG_stream_fragment)</td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Logs a WARNING message into <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a> <code>*get_logger()</code> with <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">flow::log::Component</a> <code>get_log_component()</code>, if such logging is enabled by that <code>Logger</code>. </p>
<p >Supplies context information to be potentially logged with message, like current time, source file/line/function, and thread ID/nickname info, in addition to the message, component, and severity. The severity checked against (and potentially logged in its own right) is <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">flow::log::Sev</a>:S_WARNING.</p>
<p >More precisely, checks whether logging warnings is currently enabled in the <code>Logger*</code> returned by <code>get_logger()</code> in the macro invocation's context; if not does nothing; if so constructs and logs the message as a warning via <a class="el" href="log_8hpp.html#a5daa2b6d16edea74bb8bddc75f7fb801" title="Identical to FLOW_LOG_WITH_CHECKING() but foregoes the filter (Logger::should_log()) check.">FLOW_LOG_WITHOUT_CHECKING()</a>. Also, if <code>get_logger()</code> is null, then the effect is the same as a <code>get_logger()-&gt;should_log()</code> returning <code>false</code> (meaning it is a no-op).</p>
<p ><code>get_logger()</code> must exist, and if not null then <code>get_logger()</code> (returning <code>Logger*</code>) and <code>get_log_component()</code> (returning <code>const Component&amp;</code>) must return a valid pointer and reference to <code>Logger</code> and <code>Component</code>, respectively. Most of the time these are available due to most logging code being in classes deriving from <a class="el" href="classflow_1_1log_1_1Log__context.html" title="Convenience class that simply stores a Logger and/or Component passed into a constructor; and returns...">flow::log::Log_context</a> which supplies those methods and takes (at construction) the values to return subsequently. In situations where this is impossible (such as <code>static</code> members methods or in free functions) or insufficient (such as when one wants to use a different component vs. the one returned by <a class="el" href="classflow_1_1log_1_1Log__context.html#a8a5fef42dc2cedf3c0d1a6e83beb2948" title="Returns reference to the stored Component object, particularly as many FLOW_LOG_*() macros expect.">flow::log::Log_context::get_log_component()</a>), use <a class="el" href="log_8hpp.html#ae4b5d4fdd2eb052615620879dd74af95" title="For the rest of the block within which this macro is instantiated, causes all FLOW_LOG_....">FLOW_LOG_SET_CONTEXT()</a>.</p>
<h3>Final log output subleties</h3>
<p >We assume for this discussion that the notion of order of final output (to device/file/network/whatever) exists, and that the <code>get_logger()</code> indeed safely outputs message M1 entirely before M2, or vice versa, for every pair of messages (in this context by message we mean message+metadata pair) ever passed to <code>do_log()</code>. With that assumption in effect (IF indeed it is):</p><ul>
<li>In a given thread T, and assuming the same <code>get_logger()</code>, if <code>FLOW_LOG_*(M1);</code> is called before <code>FLOW_LOG_*(M2);</code>, and both are successfully output by logger, then the final output order must have M1 precede M2, not vice versa.<ul>
<li>In addition, assuming monotonically increasing time stamps, as time flows (which is the case most of the time with exceptions due to computer-clock adjustments and similar), M1's time stamp will be earlier (ignoring rounding) than M2's.</li>
</ul>
</li>
<li>If, instead, M1 is logged in thread T1, while M2 is logged in thread T2:<ul>
<li>If the 2 <code>FLOW_LOG_*()</code> calls are chronologically disjoint, then again the final output must also have M1 precede M2 if M1 went first; and vice versa.<ul>
<li>Time stamps (under a well behaved clock again), again, will match this order.</li>
</ul>
</li>
<li>If the 2 <code>FLOW_LOG_*()</code> calls chronologically overlap, then either final output order is possible.<ul>
<li>Moreover if M1 precedes M2 in the output, formally time stamps might be in the opposite order (even assuming, again, a well behaved clock). (Informally, given how this is implemented internally, this is unlikely to be observed in practice, barring a wide absolute discrepancy between how long it takes to evaluate <code>ARG_stream_fragment</code> in M1 vs. M2.)</li>
</ul>
</li>
</ul>
</li>
</ul>
<p >The time stamp is obtained as soon as practically possible within the body of this macro. Hence it reflects the time at the moment just after the pre-logging statement finished, just before the log call site executes. <em>After</em> this is when <code>ARG_stream_fragment</code> is evaluated &ndash; assuming the filter check passes &ndash; and only after that might the final output get queued (or possibly synchronously output, depending on nature of <code>get_logger()</code>). This is why it's technically possible that (even in the absence of system time going backwards) 2 messages from 2 different threads might appear in the final output with slightly out-of-order time stamps. Informally, this is unlikely, because the <code>ARG_stream_fragment</code> evaluation would be on the order of a bunch of instructions that would complete in less time than the microsecond resolution of time stamp output, in most cases, or maybe a handful of microseconds. Anecdotally, I (ygoldfel) don't recall one instance of seeing this (out-of-order time stamps due to the concurrency race implied by the above mechanism). Nevertheless I mention it here for completeness, as well as to explain how it works.</p>
<h3>Severity selection</h3>
<p >Before selecting a severity for your log call site, please consider the discussion in the <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">flow::log::Sev</a> doc header.</p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">ARG_stream_fragment</td><td>Same as in <a class="el" href="log_8hpp.html#a5daa2b6d16edea74bb8bddc75f7fb801" title="Identical to FLOW_LOG_WITH_CHECKING() but foregoes the filter (Logger::should_log()) check.">FLOW_LOG_WITHOUT_CHECKING()</a>.</td></tr>
  </table>
  </dd>
</dl>
<dl class="todo"><dt><b><a class="el" href="todo.html#_todo000022">Todo:</a></b></dt><dd>We can avoid using macros for this and similar APIs by requiring the user to use commas instead of the usual <code>&lt;&lt;</code> and by implementing this as a variadic function template (C++11 feature).</dd></dl>
<p >Thus, while it'd be no longer possible to write</p>
<div class="fragment"><div class="line"><a class="code hl_define" href="log_8hpp.html#a626c7dc4d3b4dc0b32a8aac8624d66bc">FLOW_LOG_WARNING</a>(<span class="stringliteral">&quot;Result: [&quot;</span> &lt;&lt; std::setfill(<span class="charliteral">&#39;0&#39;</span>) &lt;&lt; num &lt;&lt; <span class="stringliteral">&quot;].&quot;</span>);</div>
</div><!-- fragment --><p >one would instead write</p>
<div class="fragment"><div class="line">flow::log::warning(<span class="stringliteral">&quot;Result: [&quot;</span>, std::setfill(<span class="charliteral">&#39;0&#39;</span>), num, <span class="stringliteral">&quot;].&quot;</span>);</div>
</div><!-- fragment --><p >which is fairly close and still reasonably readable. However, one would need to be mindful of performance; hopefully the optimizer would still inline everything instead of adding a number of function calls compared to this macro implementation whose side benefit is guaranteed inlining. Generally, though, macros are bad and should be eliminated where possible; just don't mess up speed in something as common as logging. In addition, if it's NOT inlined, the number of functions generated by the template's many instantiations would be rather large, though I suppose that's not necessarily <em>worse</em> than full-on inlining thereof &ndash; just <em>different</em>. (Still, consider how many different configurations would pop up as a result of all the different log messages!) Also keep in mind that <em>fully</em> inlining all of this would require the build engine to be capable of link-time optimization (FLTO), and the build script to enable FLTO. <em>Unfortunately</em> it would be impossible for the non-macro to refer to a <code>get_logger()</code> in the call's context, so it would be necessary for this to be passed in as an argument, significantly lowering the ease of use of the API. That said, <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a> itself could simply implement all these APIs as class methods instead of their being free functions. Then one could even (when desired) write such things as</p>
<div class="fragment"><div class="line">Logger some_logger(...); <span class="comment">// Some Logger that is not available through get_logger() as would be more typical.</span></div>
<div class="line">some_logger.warning(<span class="stringliteral">&quot;Error detected: [&quot;</span>, err_num, <span class="stringliteral">&quot;].&quot;</span>);</div>
</div><!-- fragment --><p >and therefore <a class="el" href="log_8hpp.html#ae4b5d4fdd2eb052615620879dd74af95" title="For the rest of the block within which this macro is instantiated, causes all FLOW_LOG_....">FLOW_LOG_SET_CONTEXT()</a> (another "tricky" macro) could be eliminated due to lack of necessity. Finally, <a class="el" href="classflow_1_1log_1_1Log__context.html" title="Convenience class that simply stores a Logger and/or Component passed into a constructor; and returns...">flow::log::Log_context</a> (in the current design, to be derived from by all logging classes) would be used like this:</p>
<div class="fragment"><div class="line">get_logger()-&gt;warning(<span class="stringliteral">&quot;Error detected: [&quot;</span>, err_num, <span class="stringliteral">&quot;].&quot;</span>);</div>
</div><!-- fragment --><p >It might also be advisable, for code brevity in such commonly referenced APIs, to add trivial forwarding methods to <a class="el" href="classflow_1_1log_1_1Log__context.html" title="Convenience class that simply stores a Logger and/or Component passed into a constructor; and returns...">flow::log::Log_context</a>. This is slightly questionable, as it's quite a bit of boiler-plate (needed every time one might change this overall API) just to remove a few characters from each log call. The above call would become:</p>
<div class="fragment"><div class="line">log_warning(<span class="stringliteral">&quot;Error detected: [&quot;</span>, err_num, <span class="stringliteral">&quot;].&quot;</span>); <span class="comment">// Invoke superclass Log_context&#39;s Logger::warning() method.</span></div>
</div><!-- fragment --><p >which is a little more compact. That can also be accomplished by having <a class="el" href="classflow_1_1log_1_1Log__context.html" title="Convenience class that simply stores a Logger and/or Component passed into a constructor; and returns...">flow::log::Log_context</a> implement <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a> itself. As a last note, <code>__LINE__</code> (etc.) can only be made useful via a macro, so one would still be required to wrap around any API suggested above in a simple macro &ndash; but this would be far superior (in this particular dimension of avoiding macro insanity) to the level of macro-ness required at the moment. All in all, while I do hate macros, the present design seems reasonably strong, so the above rejiggering ideas don't feel like no-brainers. </p>

</div>
</div>
<a id="a1bd954e4451fd00d23dec6b85ef15774" name="a1bd954e4451fd00d23dec6b85ef15774"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a1bd954e4451fd00d23dec6b85ef15774">&#9670;&nbsp;</a></span>FLOW_LOG_WARNING_WITHOUT_CHECKING</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">#define FLOW_LOG_WARNING_WITHOUT_CHECKING</td>
          <td>(</td>
          <td class="paramtype">&#160;</td>
          <td class="paramname">ARG_stream_fragment</td><td>)</td>
          <td>&#160;&#160;&#160;  <a class="el" href="log_8hpp.html#a5daa2b6d16edea74bb8bddc75f7fb801">FLOW_LOG_WITHOUT_CHECKING</a>(::flow::log::Sev::S_WARNING, ARG_stream_fragment)</td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Logs a WARNING message into <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a> <code>*get_logger()</code> with <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">flow::log::Component</a> <code>get_log_component()</code> regardless of whether such logging is enabled by the <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a>. </p>
<p >Analogous to <a class="el" href="log_8hpp.html#a626c7dc4d3b4dc0b32a8aac8624d66bc" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING()</a> but without checking for whether it is enabled (you should do so yourself; see the following note on this topic).</p>
<dl class="section note"><dt>Note</dt><dd>If <code>get_logger()</code> is null, this is a no-op. In practice, though, this case should have been eliminated as part of heeding the following warning:</dd></dl>
<dl class="section warning"><dt>Warning</dt><dd>If invoking this directly, API user must manually ensure the severity is enabled in the logger. Not doing so breaks (unenforced but nevertheless mandatory) rules of logging system.</dd></dl>
<h3>Severity selection</h3>
<p >Before selecting a severity for your log call site, please consider the discussion in the <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">flow::log::Sev</a> doc header.</p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">ARG_stream_fragment</td><td>Same as in <a class="el" href="log_8hpp.html#a626c7dc4d3b4dc0b32a8aac8624d66bc" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING()</a>. </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
<a id="a692bbadd8b5c3e9cef7a0bbea1915e66" name="a692bbadd8b5c3e9cef7a0bbea1915e66"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a692bbadd8b5c3e9cef7a0bbea1915e66">&#9670;&nbsp;</a></span>FLOW_LOG_WITH_CHECKING</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">#define FLOW_LOG_WITH_CHECKING</td>
          <td>(</td>
          <td class="paramtype">&#160;</td>
          <td class="paramname">ARG_sev, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">&#160;</td>
          <td class="paramname">ARG_stream_fragment&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">
<b>Value:</b><div class="fragment"><div class="line">  <a class="code hl_define" href="util__fwd_8hpp.html#a402a1fb61d3fe4ca6767729e38620d6d">FLOW_UTIL_SEMICOLON_SAFE</a> \</div>
<div class="line">  ( \</div>
<div class="line">    <a class="code hl_class" href="classflow_1_1log_1_1Logger.html">::flow::log::Logger</a> <span class="keyword">const</span> * <span class="keyword">const</span> FLOW_LOG_W_CHK_logger = get_logger(); \</div>
<div class="line">    if (FLOW_LOG_W_CHK_logger &amp;&amp; FLOW_LOG_W_CHK_logger-&gt;<a class="code hl_function" href="classflow_1_1log_1_1Logger.html#ac8a2e7a33fe3fbc0c29ead62ed98c022">should_log</a>(ARG_sev, get_log_component())) \</div>
<div class="line">    { \</div>
<div class="line">      FLOW_LOG_WITHOUT_CHECKING(ARG_sev, ARG_stream_fragment); \</div>
<div class="line">    } \</div>
<div class="line">  )</div>
<div class="ttc" id="aclassflow_1_1log_1_1Logger_html_ac8a2e7a33fe3fbc0c29ead62ed98c022"><div class="ttname"><a href="classflow_1_1log_1_1Logger.html#ac8a2e7a33fe3fbc0c29ead62ed98c022">flow::log::Logger::should_log</a></div><div class="ttdeci">virtual bool should_log(Sev sev, const Component &amp;component) const =0</div><div class="ttdoc">Given attributes of a hypothetical message that would be logged, return true if that message should b...</div></div>
<div class="ttc" id="autil__fwd_8hpp_html_a402a1fb61d3fe4ca6767729e38620d6d"><div class="ttname"><a href="util__fwd_8hpp.html#a402a1fb61d3fe4ca6767729e38620d6d">FLOW_UTIL_SEMICOLON_SAFE</a></div><div class="ttdeci">#define FLOW_UTIL_SEMICOLON_SAFE(ARG_func_macro_definition)</div><div class="ttdoc">Use this to create a semicolon-safe version of a &quot;void&quot; functional macro definition consisting of at ...</div><div class="ttdef"><b>Definition:</b> util_fwd.hpp:1079</div></div>
</div><!-- fragment -->
<p>Logs a message of the specified severity into <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a> <code>*get_logger()</code> with <a class="el" href="classflow_1_1log_1_1Component.html" title="A light-weight class, each object storing a component payload encoding an enum value from enum type o...">flow::log::Component</a> <code>get_log_component()</code> if such logging is enabled by said <a class="el" href="classflow_1_1log_1_1Logger.html" title="Interface that the user should implement, passing the implementing Logger into logging classes (Flow&#39;...">flow::log::Logger</a>. </p>
<p >The behavior is identical to that by <a class="el" href="log_8hpp.html#a626c7dc4d3b4dc0b32a8aac8624d66bc" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING()</a> and similar, but one specifies the severity as an argument instead of it being hard-coded into the macro name itself.</p>
<dl class="section note"><dt>Note</dt><dd>It is important that ARG_stream_fragment is actually evaluated only if Logger::should_log() is true. Otherwise resources are wasted on constructing a message string that never gets logged. That's a (the?) reason Logger:should_log() and Logger::do_log() are mutually decoupled in that interface.</dd></dl>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">ARG_sev</td><td>Severity (type log::Sev). </td></tr>
    <tr><td class="paramname">ARG_stream_fragment</td><td>Same as in <a class="el" href="log_8hpp.html#a626c7dc4d3b4dc0b32a8aac8624d66bc" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING()</a>.</td></tr>
  </table>
  </dd>
</dl>
<h3>Severity selection</h3>
<p >Before selecting a severity for your log call site, please consider the discussion in the <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">flow::log::Sev</a> doc header. </p>

</div>
</div>
<a id="a5daa2b6d16edea74bb8bddc75f7fb801" name="a5daa2b6d16edea74bb8bddc75f7fb801"></a>
<h2 class="memtitle"><span class="permalink"><a href="#a5daa2b6d16edea74bb8bddc75f7fb801">&#9670;&nbsp;</a></span>FLOW_LOG_WITHOUT_CHECKING</h2>

<div class="memitem">
<div class="memproto">
      <table class="memname">
        <tr>
          <td class="memname">#define FLOW_LOG_WITHOUT_CHECKING</td>
          <td>(</td>
          <td class="paramtype">&#160;</td>
          <td class="paramname">ARG_sev, </td>
        </tr>
        <tr>
          <td class="paramkey"></td>
          <td></td>
          <td class="paramtype">&#160;</td>
          <td class="paramname">ARG_stream_fragment&#160;</td>
        </tr>
        <tr>
          <td></td>
          <td>)</td>
          <td></td><td></td>
        </tr>
      </table>
</div><div class="memdoc">

<p>Identical to <a class="el" href="log_8hpp.html#a692bbadd8b5c3e9cef7a0bbea1915e66" title="Logs a message of the specified severity into flow::log::Logger *get_logger() with flow::log::Compone...">FLOW_LOG_WITH_CHECKING()</a> but foregoes the filter (Logger::should_log()) check. </p>
<p >No-op if <code>get_logger()</code> returns null. Internally, all other log-call-site macros ultimately build on top of this one except <a class="el" href="log_8hpp.html#ab07c4bca2d59872736d0d9717b05aeb1" title="Lowest-level logging API accessible to the user, this is identical to FLOW_LOG_WITHOUT_CHECKING() but...">FLOW_LOG_DO_LOG()</a>.</p>
<p >Context information obtained and possibly logged is file/function/line, thread nickname/ID, time stamp, etc. The message is given as the <code>&lt;&lt;</code>-using <code>ostream</code> fragment in <code>ARG_stream_fragment</code> argument. Example (note the 2nd argument containing a stream output fragment):</p>
<div class="fragment"><div class="line"><a class="code hl_define" href="log_8hpp.html#a5daa2b6d16edea74bb8bddc75f7fb801">FLOW_LOG_WITHOUT_CHECKING</a>(<a class="code hl_enumvalue" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a4aee6034ce9dbc2b5c36f27c80abe021">flow::log::Sev::S_WARNING</a>,</div>
<div class="line">                          <span class="stringliteral">&quot;Failed [&quot;</span> &lt;&lt; n_times &lt;&lt; <span class="stringliteral">&quot;] times; bailing out!&quot;</span>);</div>
<div class="ttc" id="alog_8hpp_html_a5daa2b6d16edea74bb8bddc75f7fb801"><div class="ttname"><a href="log_8hpp.html#a5daa2b6d16edea74bb8bddc75f7fb801">FLOW_LOG_WITHOUT_CHECKING</a></div><div class="ttdeci">#define FLOW_LOG_WITHOUT_CHECKING(ARG_sev, ARG_stream_fragment)</div><div class="ttdoc">Identical to FLOW_LOG_WITH_CHECKING() but foregoes the filter (Logger::should_log()) check.</div><div class="ttdef"><b>Definition:</b> log.hpp:532</div></div>
<div class="ttc" id="anamespaceflow_1_1log_html_a5c602384e6fe9d7642740ac2fae4ad04a4aee6034ce9dbc2b5c36f27c80abe021"><div class="ttname"><a href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04a4aee6034ce9dbc2b5c36f27c80abe021">flow::log::Sev::S_WARNING</a></div><div class="ttdeci">@ S_WARNING</div><div class="ttdoc">Message indicates a &quot;bad&quot; condition that is not frequent enough to be of severity Sev::S_TRACE.</div></div>
</div><!-- fragment --><dl class="section note"><dt>Note</dt><dd>This macro is the lowest-level API that user should invoke to actually log, except <a class="el" href="log_8hpp.html#ab07c4bca2d59872736d0d9717b05aeb1" title="Lowest-level logging API accessible to the user, this is identical to FLOW_LOG_WITHOUT_CHECKING() but...">FLOW_LOG_DO_LOG()</a>. Usually she'd invoke something higher-level like <a class="el" href="log_8hpp.html#a626c7dc4d3b4dc0b32a8aac8624d66bc" title="Logs a WARNING message into flow::log::Logger *get_logger() with flow::log::Component get_log_compone...">FLOW_LOG_WARNING()</a>, etc.; but at times more control is desirable for performance or other reasons &ndash; but even then one should not call anything below this level without an extremely excellent reason. See <a class="el" href="log_8hpp.html#ab07c4bca2d59872736d0d9717b05aeb1" title="Lowest-level logging API accessible to the user, this is identical to FLOW_LOG_WITHOUT_CHECKING() but...">FLOW_LOG_DO_LOG()</a> for discussion of the latter.</dd></dl>
<dl class="section warning"><dt>Warning</dt><dd>If invoking this directly, API user must manually ensure the severity is enabled in the <code>Logger</code>. Not doing so breaks (unenforced but nevertheless mandatory) rules of logging system.</dd></dl>
<h3>Severity selection</h3>
<p >Before selecting a severity for your log call site, please consider the discussion in the <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">flow::log::Sev</a> doc header.</p>
<dl class="params"><dt>Parameters</dt><dd>
  <table class="params">
    <tr><td class="paramname">ARG_sev</td><td>Severity (type <a class="el" href="namespaceflow_1_1log.html#a5c602384e6fe9d7642740ac2fae4ad04" title="Enumeration containing one of several message severity levels, ordered from highest to lowest.">flow::log::Sev</a>). </td></tr>
    <tr><td class="paramname">ARG_stream_fragment</td><td>Fragment of code as if writing to a standard <code>ostream</code>. A terminating newline will be auto-appended to this eventually and therefore should generally not be included by the invoker. (Such a terminating newline would manifest as a blank line, likely.) </td></tr>
  </table>
  </dd>
</dl>

</div>
</div>
</div><!-- contents -->
<!-- start footer part -->
<hr class="footer"/><address class="footer"><small>
Generated on Fri Mar 28 2025 22:55:32 for Flow by&#160;<a href="https://www.doxygen.org/index.html"><img class="footer" src="doxygen.svg" width="104" height="31" alt="doxygen"/></a> 1.9.4
</small></address>
</body>
</html>
